#include <stdio.h>
#include <stdlib.h>
#include "TipoError.h"

void cargarLista()
{
	TuplaError * aux1 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux1->error = 1;
	aux1->tipo  = "**** Error de tipos en la linea";
	TuplaError * aux2 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux2->error = 2;
	aux2->tipo  = "**** Error: Identificador no declarado en la linea";
	TuplaError * aux3 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux3->error = 3;
	aux3->tipo = "**** Error: Redeclaracion de identificador en la linea";
	TuplaError * aux4 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux4->error = 4;
	aux4->tipo = "**** Error de retorno: Se esperaba un <int>. Linea";
	TuplaError * aux5 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux5->error = 5;
	aux5->tipo = "**** Warnning: Casting implicito en la linea";
	TuplaError * aux6 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux6->error = 6;
	aux6->tipo = "**** Error tipos incompatibles. Uso ! <int>. Linea";
	TuplaError * aux7 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux7->error = 7;
	aux7->tipo = "**** Error tipos incompatibles. Uso <int> % <int>. Linea ";
	TuplaError * aux8 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux8->error = 8;
	aux8->tipo = "**** Error en la condicion. Debe ser un <int>. Linea ";
	TuplaError * aux9 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux9->error = 9;
	aux9->tipo = "**** Error de retorno: Se esperaba un <float>. Linea ";
	TuplaError * aux10 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux10->error = 10;
	aux10->tipo = "**** Error redeclaracion de parametros en la linea ";
	TuplaError * aux11 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux11->error = 11;
	aux11->tipo = "**** Error Simbolo no valido en la linea ";
	TuplaError * aux12 = (TuplaError *) malloc (sizeof(struct TupleError));
	aux12->error = 12;
	aux12->tipo = "**** Error sentencia break o continue mal ubicada en la linea ";
    insertarError(aux1);
    insertarError(aux2);
    insertarError(aux3);
    insertarError(aux4);
    insertarError(aux5);
    insertarError(aux6);
    insertarError(aux7);
    insertarError(aux8);
    insertarError(aux9);
    insertarError(aux10);
    insertarError(aux11);
    insertarError(aux12);
}


void insertarError(TuplaError* t)
{
	ItemList *nuevo = (ItemList *) malloc (sizeof(struct ElementoLista));	
	if (nuevo == NULL){	       
		printf ("Error: no hay memoria disponible. \n");
		exit(1);
	}
	nuevo->t_error = t;
	if (lista->ultimo == NULL){
		nuevo->sig = NULL;
		lista->primero = nuevo;
		lista->ultimo = nuevo;
	}else{
		lista->ultimo->sig = nuevo;
		nuevo->sig = NULL;
		lista->ultimo = nuevo;
	}
	lista->tamanio++; 
}

void initListaErrores()
{
	lista = (LList *) malloc (sizeof(struct List));
	lista->ultimo = NULL;
	lista->primero = NULL;
	lista->tamanio = 0;
	cargarLista(lista);
}

char* buscarError(int num)
{
	if (lista == NULL){
		printf("Lista nula");	
		exit(1);
	}else{
		ItemList *aux = lista->primero;
		int i;
		for (i = 0; i< lista->tamanio; ++i){
			if (aux->t_error->error == num)
				return aux->t_error->tipo;
			aux=aux->sig;	
		}
	}
	
}

void mostrarError(int error, int linea)
{
	char * aux = buscarError(error);
	printf("%s %i ****\n",aux,linea	);	
}

void mostrarError2(int error, int linea, int columna)
{
	char * aux = buscarError(error);
	printf("%s %i, columna %i ****\n",aux,linea,columna);	
}

void mostrarListaError()
{
if ((lista->tamanio == 0) || (lista == NULL)){
		printf ("Lista vacia\n");		
	}else{
		ItemList * actual;
		int i;
		actual = lista->primero;
		for(i=0;i<lista->tamanio;++i){
			printf("(");	
			printf("%i", actual->t_error->error);
			printf(",");	
			printf("%s", actual->t_error->tipo);
			printf(")");	
			actual = actual->sig;
	  	}
		printf("\n");
	}
}
